{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# How to use CNN with time series data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The regular measurements of time series result in a similar grid-like data structure as for the image data we have focused on so far. As a result, we can use CNN architectures for univariate and multivariate time series. In the latter case, we consider different time series as channels, similar to the different color signals."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Imports & Settings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-22T23:37:07.234013Z",
     "start_time": "2020-06-22T23:37:05.167485Z"
    }
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "import sys\n",
    "from time import time\n",
    "from pathlib import Path\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from scipy.stats import spearmanr\n",
    "from sklearn.feature_selection import mutual_info_regression\n",
    "\n",
    "import tensorflow as tf\n",
    "tf.autograph.set_verbosity(0, True)\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras import regularizers\n",
    "from tensorflow.keras.callbacks import EarlyStopping\n",
    "from tensorflow.keras.layers import (Dense, \n",
    "                                     Flatten, \n",
    "                                     Conv1D, \n",
    "                                     MaxPooling1D, \n",
    "                                     Dropout, \n",
    "                                     BatchNormalization)\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-22T23:37:07.264708Z",
     "start_time": "2020-06-22T23:37:07.235337Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using GPU\n"
     ]
    }
   ],
   "source": [
    "gpu_devices = tf.config.experimental.list_physical_devices('GPU')\n",
    "if gpu_devices:\n",
    "    print('Using GPU')\n",
    "    tf.config.experimental.set_memory_growth(gpu_devices[0], True)\n",
    "else:\n",
    "    print('Using CPU')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-22T23:37:07.280881Z",
     "start_time": "2020-06-22T23:37:07.266207Z"
    }
   },
   "outputs": [],
   "source": [
    "sys.path.insert(1, Path(sys.path[0], '..').as_posix())\n",
    "from utils import MultipleTimeSeriesCV, format_time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-22T23:37:07.292403Z",
     "start_time": "2020-06-22T23:37:07.282293Z"
    }
   },
   "outputs": [],
   "source": [
    "np.random.seed(1)\n",
    "tf.random.set_seed(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-22T23:37:07.301536Z",
     "start_time": "2020-06-22T23:37:07.294419Z"
    }
   },
   "outputs": [],
   "source": [
    "sns.set_style('whitegrid')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-22T23:37:07.310212Z",
     "start_time": "2020-06-22T23:37:07.303580Z"
    }
   },
   "outputs": [],
   "source": [
    "results_path = Path('results', 'time_series')\n",
    "if not results_path.exists():\n",
    "    results_path.mkdir(parents=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prepare Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-22T23:37:13.990608Z",
     "start_time": "2020-06-22T23:37:07.314853Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "DatetimeIndex: 4706 entries, 2000-01-03 to 2018-03-27\n",
      "Columns: 3199 entries, A to ZUMZ\n",
      "dtypes: float64(3199)\n",
      "memory usage: 114.9 MB\n"
     ]
    }
   ],
   "source": [
    "prices = (pd.read_hdf('../data/assets.h5', 'quandl/wiki/prices')\n",
    "          .adj_close\n",
    "          .unstack().loc['2000':])\n",
    "prices.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Compute monthly returns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-22T23:37:14.139660Z",
     "start_time": "2020-06-22T23:37:13.991985Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "DatetimeIndex: 215 entries, 2017-12-31 to 2000-02-29\n",
      "Freq: -1M\n",
      "Columns: 1511 entries, A to ZQK\n",
      "dtypes: float64(1511)\n",
      "memory usage: 2.5 MB\n"
     ]
    }
   ],
   "source": [
    "returns = (prices\n",
    "           .resample('M')\n",
    "           .last()\n",
    "           .pct_change()\n",
    "           .dropna(how='all')\n",
    "           .loc['2000': '2017']\n",
    "           .dropna(axis=1)\n",
    "           .sort_index(ascending=False))\n",
    "\n",
    "# remove outliers likely representing data errors\n",
    "returns = returns.where(returns<1).dropna(axis=1)\n",
    "returns.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create model data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-22T23:37:14.143869Z",
     "start_time": "2020-06-22T23:37:14.141150Z"
    }
   },
   "outputs": [],
   "source": [
    "n = len(returns)\n",
    "nlags = 12\n",
    "lags = list(range(1, nlags + 1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-22T23:37:15.556153Z",
     "start_time": "2020-06-22T23:37:14.145842Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "MultiIndex: 305222 entries, ('A', Timestamp('2001-03-31 00:00:00')) to ('ZQK', Timestamp('2017-12-31 00:00:00'))\n",
      "Data columns (total 13 columns):\n",
      " #   Column  Non-Null Count   Dtype  \n",
      "---  ------  --------------   -----  \n",
      " 0   label   305222 non-null  float64\n",
      " 1   1       305222 non-null  float64\n",
      " 2   2       305222 non-null  float64\n",
      " 3   3       305222 non-null  float64\n",
      " 4   4       305222 non-null  float64\n",
      " 5   5       305222 non-null  float64\n",
      " 6   6       305222 non-null  float64\n",
      " 7   7       305222 non-null  float64\n",
      " 8   8       305222 non-null  float64\n",
      " 9   9       305222 non-null  float64\n",
      " 10  10      305222 non-null  float64\n",
      " 11  11      305222 non-null  float64\n",
      " 12  12      305222 non-null  float64\n",
      "dtypes: float64(13)\n",
      "memory usage: 31.5+ MB\n"
     ]
    }
   ],
   "source": [
    "cnn_data = []\n",
    "for i in range(n-nlags-1):\n",
    "    df = returns.iloc[i:i+nlags+1]        # select outcome and lags\n",
    "    date = df.index.max()                 # use outcome date\n",
    "    cnn_data.append(df.reset_index(drop=True)  # append transposed series\n",
    "                    .transpose()\n",
    "                    .assign(date=date)\n",
    "                    .set_index('date', append=True)\n",
    "                    .sort_index(1, ascending=True))\n",
    "\n",
    "cnn_data = (pd.concat(cnn_data)\n",
    "            .rename(columns={0: 'label'})\n",
    "            .sort_index())\n",
    "\n",
    "cnn_data.info(null_counts=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evaluate features"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mutual Information"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-22T23:37:15.559489Z",
     "start_time": "2020-06-22T23:37:15.557296Z"
    }
   },
   "outputs": [],
   "source": [
    "# mi = mutual_info_regression(X=cnn_data.drop('label', axis=1), y=cnn_data.label)\n",
    "# mi = pd.Series(mi, index=cnn_data.drop('label', axis=1).columns)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Information Coefficient"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-22T23:37:15.570129Z",
     "start_time": "2020-06-22T23:37:15.561721Z"
    }
   },
   "outputs": [],
   "source": [
    "# ic = {}\n",
    "# for lag in lags:\n",
    "#     ic[lag] = spearmanr(cnn_data.label, cnn_data[lag])\n",
    "# ic = pd.DataFrame(ic, index=['IC', 'p-value']).T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-22T23:37:15.578679Z",
     "start_time": "2020-06-22T23:37:15.571376Z"
    }
   },
   "outputs": [],
   "source": [
    "# ax = ic.plot.bar(rot=0, figsize=(14, 4),\n",
    "#                  ylim=(-0.05, .05),\n",
    "#                  title='Feature Evaluation')\n",
    "# ax.set_xlabel('Lag')\n",
    "# sns.despine()\n",
    "# plt.tight_layout()\n",
    "# plt.savefig(results_path / 'cnn_ts1d_feature_ic', dpi=300)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot Metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-22T23:37:15.587881Z",
     "start_time": "2020-06-22T23:37:15.582281Z"
    }
   },
   "outputs": [],
   "source": [
    "# metrics = pd.concat([mi.to_frame('Mutual Information'),\n",
    "#                      ic.IC.to_frame('Information Coefficient')], axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-22T23:37:15.596038Z",
     "start_time": "2020-06-22T23:37:15.589176Z"
    }
   },
   "outputs": [],
   "source": [
    "# ax = metrics.plot.bar(figsize=(12, 4), rot=0)\n",
    "# ax.set_xlabel('Lag')\n",
    "# sns.despine()\n",
    "# plt.tight_layout()\n",
    "# plt.savefig(results_path / 'ts1d_metrics', dpi=300)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## CNN"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model Architecture"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We design a simple one-layer CNN that uses one-dimensional convolutions combined with max pooling to learn time series patterns:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-22T23:37:15.609438Z",
     "start_time": "2020-06-22T23:37:15.598298Z"
    }
   },
   "outputs": [],
   "source": [
    "def get_model(filters=32, kernel_size=5, pool_size=2):\n",
    "    model = Sequential([Conv1D(filters=filters,\n",
    "                               kernel_size=kernel_size,\n",
    "                               activation='relu',\n",
    "                               padding='causal',\n",
    "                               input_shape=input_shape,\n",
    "                               use_bias=True,\n",
    "                               kernel_regularizer=regularizers.l1_l2(l1=1e-5,\n",
    "                                                                     l2=1e-5)),\n",
    "                        MaxPooling1D(pool_size=pool_size),\n",
    "                        Flatten(),\n",
    "                        BatchNormalization(),\n",
    "                        Dense(1, activation='linear')])\n",
    "    model.compile(loss='mse',\n",
    "                  optimizer='Adam')\n",
    "    return model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set up CV"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-22T23:37:15.625962Z",
     "start_time": "2020-06-22T23:37:15.611671Z"
    }
   },
   "outputs": [],
   "source": [
    "cv = MultipleTimeSeriesCV(n_splits=12 * 3,\n",
    "                          train_period_length=12 * 5,\n",
    "                          test_period_length=1,\n",
    "                          lookahead=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-22T23:37:15.640505Z",
     "start_time": "2020-06-22T23:37:15.628132Z"
    }
   },
   "outputs": [],
   "source": [
    "input_shape = nlags, 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-22T23:37:15.650178Z",
     "start_time": "2020-06-22T23:37:15.642209Z"
    }
   },
   "outputs": [],
   "source": [
    "def get_train_valid_data(X, y, train_idx, test_idx):\n",
    "    x_train, y_train = X.iloc[train_idx, :], y.iloc[train_idx]\n",
    "    x_val, y_val = X.iloc[test_idx, :], y.iloc[test_idx]\n",
    "    m = X.shape[1]\n",
    "    return (x_train.values.reshape(-1, m, 1), y_train,\n",
    "            x_val.values.reshape(-1, m, 1), y_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-22T23:37:15.658024Z",
     "start_time": "2020-06-22T23:37:15.651595Z"
    }
   },
   "outputs": [],
   "source": [
    "batch_size = 64\n",
    "epochs = 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-22T23:37:15.669680Z",
     "start_time": "2020-06-22T23:37:15.660185Z"
    }
   },
   "outputs": [],
   "source": [
    "filters = 32\n",
    "kernel_size = 4\n",
    "pool_size = 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-22T23:37:16.476342Z",
     "start_time": "2020-06-22T23:37:15.672992Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv1d (Conv1D)              (None, 12, 32)            160       \n",
      "_________________________________________________________________\n",
      "max_pooling1d (MaxPooling1D) (None, 3, 32)             0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 96)                0         \n",
      "_________________________________________________________________\n",
      "batch_normalization (BatchNo (None, 96)                384       \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 1)                 97        \n",
      "=================================================================\n",
      "Total params: 641\n",
      "Trainable params: 449\n",
      "Non-trainable params: 192\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "get_model(filters=filters,\n",
    "          kernel_size=kernel_size, \n",
    "          pool_size=pool_size).summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-23T00:05:03.064200Z",
     "start_time": "2020-06-22T23:37:16.477886Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "01 | 00:00:41 |   3 |   1.9 ( 45.76%) |   1.9\n",
      "02 | 00:01:46 |  11 |   2.4 ( 34.95%) |   2.2\n",
      "03 | 00:03:04 |  15 |   1.4 ( 59.61%) |   1.9\n",
      "04 | 00:03:38 |   1 |  -1.6 ( 52.22%) |   1.0\n",
      "05 | 00:04:13 |   1 |   3.0 ( 24.90%) |   1.4\n",
      "06 | 00:04:46 |   1 |   4.3 (  9.63%) |   1.9\n",
      "07 | 00:05:55 |  14 |   4.2 ( 10.18%) |   2.2\n",
      "08 | 00:06:38 |  17 |   2.4 ( 35.67%) |   2.2\n",
      "09 | 00:06:58 |   2 |   2.5 ( 32.65%) |   2.3\n",
      "10 | 00:07:22 |   4 |   2.5 ( 33.57%) |   2.3\n",
      "11 | 00:07:41 |   1 |  0.96 ( 70.92%) |   2.2\n",
      "12 | 00:08:02 |   1 |   4.7 (  6.93%) |   2.4\n",
      "13 | 00:08:24 |   2 |   3.6 ( 16.38%) |   2.5\n",
      "14 | 00:08:55 |   7 |   5.0 (  5.07%) |   2.7\n",
      "15 | 00:09:14 |   1 |   2.9 ( 26.00%) |   2.7\n",
      "16 | 00:10:08 |  23 |   2.4 ( 34.92%) |   2.7\n",
      "17 | 00:10:51 |   8 |   3.3 ( 20.00%) |   2.7\n",
      "18 | 00:11:28 |   2 |   2.8 ( 28.12%) |   2.7\n",
      "19 | 00:13:05 |  22 |   4.6 (  7.32%) |   2.8\n",
      "20 | 00:13:39 |   1 |   2.0 ( 44.75%) |   2.8\n",
      "21 | 00:14:14 |   1 |   3.3 ( 20.26%) |   2.8\n",
      "22 | 00:14:56 |   4 | -0.51 ( 84.31%) |   2.6\n",
      "23 | 00:16:22 |  17 | -0.13 ( 95.87%) |   2.5\n",
      "24 | 00:17:01 |   2 |   1.4 ( 58.41%) |   2.5\n",
      "25 | 00:17:46 |   4 |   5.2 (  4.21%) |   2.6\n",
      "26 | 00:18:28 |   3 |   1.6 ( 54.50%) |   2.5\n",
      "27 | 00:19:46 |  15 |   1.4 ( 59.62%) |   2.5\n",
      "28 | 00:20:23 |   1 |   7.5 (  0.35%) |   2.7\n",
      "29 | 00:22:16 |  26 |   3.9 ( 13.36%) |   2.7\n",
      "30 | 00:22:51 |   1 |   5.2 (  4.48%) |   2.8\n",
      "31 | 00:23:46 |   8 |   2.1 ( 42.50%) |   2.8\n",
      "32 | 00:24:45 |   8 |   4.9 (  5.51%) |   2.8\n",
      "33 | 00:25:26 |   3 |  0.06 ( 98.14%) |   2.8\n",
      "34 | 00:26:02 |   1 | -0.93 ( 71.92%) |   2.6\n",
      "35 | 00:27:09 |  13 |   4.5 (  7.84%) |   2.7\n",
      "36 | 00:27:47 |   3 |   3.2 ( 20.88%) |   2.7\n"
     ]
    }
   ],
   "source": [
    "result = {}\n",
    "start = time()\n",
    "for fold, (train_idx, test_idx) in enumerate(cv.split(cnn_data)):\n",
    "    X_train, y_train, X_val, y_val = get_train_valid_data(cnn_data\n",
    "                                                          .drop('label', axis=1)\n",
    "                                                          .sort_index(ascending=False),\n",
    "                                                          cnn_data.label,\n",
    "                                                          train_idx,\n",
    "                                                          test_idx)\n",
    "    test_date = y_val.index.get_level_values('date').max()\n",
    "    model = get_model(filters=filters,\n",
    "                      kernel_size=kernel_size,\n",
    "                      pool_size=pool_size)\n",
    "    \n",
    "    best_ic = -np.inf\n",
    "    stop = 0\n",
    "    for epoch in range(50):         \n",
    "        training = model.fit(X_train, y_train,\n",
    "                             batch_size=batch_size,\n",
    "                             validation_data=(X_val, y_val),\n",
    "                             epochs=epoch + 1,\n",
    "                             initial_epoch=epoch,\n",
    "                             verbose=0,\n",
    "                             shuffle=True)\n",
    "        predicted = model.predict(X_val).squeeze()\n",
    "        ic, p_val_ = spearmanr(predicted, y_val)\n",
    "        if ic > best_ic:\n",
    "            best_ic = ic\n",
    "            p_val = p_val_\n",
    "            stop = 0\n",
    "        else:\n",
    "            stop += 1\n",
    "        if stop == 10:\n",
    "            break\n",
    "    \n",
    "    nrounds = epoch + 1 - stop\n",
    "    result[test_date] = [nrounds, best_ic, p_val]\n",
    "    df = pd.DataFrame(result, index=['epochs', 'IC', 'p-value']).T\n",
    "    msg = f'{fold + 1:02d} | {format_time(time()-start)} | {nrounds:3.0f} | '\n",
    "    print(msg + f'{best_ic*100:5.2} ({p_val:7.2%}) | {df.IC.mean()*100:5.2}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Evaluate Results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-23T00:05:03.070948Z",
     "start_time": "2020-06-23T00:05:03.065341Z"
    }
   },
   "outputs": [],
   "source": [
    "metrics = pd.DataFrame(result, index=['epochs', 'IC', 'p-value']).T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-23T00:05:03.742869Z",
     "start_time": "2020-06-23T00:05:03.072834Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ax = metrics.IC.plot(figsize=(12, 4), \n",
    "                     label='Information Coefficient',\n",
    "                     title='Validation Performance',\n",
    "                    ylim=(0, .08))\n",
    "metrics.IC.expanding().mean().plot(ax=ax, label='Cumulative Average')\n",
    "plt.legend()\n",
    "sns.despine()\n",
    "plt.tight_layout()\n",
    "plt.savefig(results_path / 'cnn_ts1d_ic', dpi=300);"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:ml4t] *",
   "language": "python",
   "name": "conda-env-ml4t-py"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.7"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": true,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "240.391px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  },
  "toc-autonumbering": true
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
